package io.servicios;

import io.Archivo;
import io.Carpeta;
import io.Cliente;
import io.ItemAgenda;
import io.ItemBusqueda;
import io.bd.GestorBD;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.sql.SQLException;
import java.util.List;

/**
 *
 * @author Mariano Zapata
 */
public class ServiciosServidor extends UnicastRemoteObject implements InterfazServiciosServidor {

    private GestorServicios gs;
    private GestorBD gbd;
    
    private static final int TAMANIO_BUFFER= 1024;
    
    private static final String EXTENSION_TEMP= ".temporal";
    private static final String ERROR_SERVICIO= "Se ha perdido la conexión con el Servidor porque ocurrió" +
            "\nun error interno en él y se ha detenido.";
    
    public ServiciosServidor(GestorServicios gs, GestorBD gbd) throws RemoteException
    {
        super();
        this.gs= gs;
        this.gbd= gbd;
    }
    
    @Override
    public int conectar(String ip, int puertoRMICliente) throws RemoteException {
        try {
            return gs.nuevaConexion(ip, puertoRMICliente);
        } catch (NotBoundException ex) {throw new RemoteException(ex.getMessage());}
    }
    
    @Override
    public void desconectar(int id) throws RemoteException {
        gs.quitarConexion(id);
    }
    
    @Override
    public boolean estaVivo() throws RemoteException {
        return true;
    }

    @Override
    public Carpeta expandirCarpeta(Carpeta padre) throws RemoteException {
        try {
            gbd.expandirCarpeta(padre, true, true);
            return padre;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta abrirExpediente(Carpeta aAbrir, int duenio) throws RemoteException {
        try {
            return gbd.abrirExpediente(aAbrir, duenio);
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
          catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public void cerrarExpediente(Carpeta aCerrar) throws RemoteException {
        try {
            gbd.cerrarExpediente(aCerrar);
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Cliente abrirCliente(Cliente aAbrir, int duenio) throws RemoteException {
        try {
            return gbd.abrirCliente(aAbrir, duenio);
        } catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public void cerrarCliente(Cliente aCerrar) throws RemoteException {
        try {
            gbd.cerrarCliente(aCerrar);
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Object[] crearCliente(Cliente aCrear, Carpeta padre, int duenio) throws RemoteException {
        try {
            Object [] o= gbd.crearCliente(aCrear, padre, duenio);
            gs.avisoActualizarCarpeta((Carpeta) o[0], duenio, InterfazServiciosServidor.AGREGAR_CLIENTE);
            return o;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta guardarCliente(Cliente aGuardar, int duenio) throws RemoteException {
        try {
            Carpeta c= gbd.guardarCliente(aGuardar);
            gs.avisoActualizarCarpeta(c, duenio, InterfazServiciosServidor.ORDENAR_CLIENTES);
            return c;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public boolean eliminarCliente(Cliente aEliminar, Carpeta padre, int eliminador) throws RemoteException {
        try {
            boolean b= gbd.eliminarCliente(aEliminar, eliminador);
            padre.setPoseeHijos(gbd.poseeHijos(padre));
            if (b)
                gs.avisoQuitarDeCarpeta(padre, aEliminar, eliminador);
            return b;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta cortarCliente(Cliente aCortar, Carpeta padreNuevo, Carpeta padreViejo, int cortador)
            throws RemoteException {
        try {
            Carpeta c= gbd.cortarCliente(aCortar, padreNuevo, cortador);
            if (c != null)
                gs.avisoCortarObjeto(aCortar, padreViejo, c, cortador);
            return c;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta copiarCliente(Cliente aCopiar, Carpeta padreNuevo, int copiador) throws RemoteException {
        try {
            Carpeta c= gbd.copiarCliente(aCopiar, padreNuevo, copiador);
            if (c != null)
                gs.avisoActualizarCarpeta(c, copiador, InterfazServiciosServidor.AGREGAR_CLIENTE);
            return c;
        } catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Object [] crearCarpeta(Carpeta aCrear, Carpeta padre, int duenio) throws RemoteException {
        try {
            Object [] o= gbd.crearCarpeta(aCrear, padre, duenio);
            gs.avisoActualizarCarpeta((Carpeta) o[0], duenio, InterfazServiciosServidor.AGREGAR_CARPETA);
            return o;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta guardarCarpeta(Carpeta aGuardar, int duenio) throws RemoteException {
        try {
            Carpeta c= gbd.guardarCarpeta(aGuardar);
            gs.avisoActualizarCarpeta(c, duenio, InterfazServiciosServidor.ORDENAR_CARPETAS);
            return c;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<Cliente> eliminarCarpeta(Carpeta aEliminar, Carpeta padre, int eliminador) throws RemoteException {
        try {
            List<Cliente> clientesEliminados= gbd.eliminarCarpeta(aEliminar, eliminador);
            padre.setPoseeHijos(gbd.poseeHijos(padre));
            if (clientesEliminados != null)
                gs.avisoQuitarDeCarpeta(padre, aEliminar, eliminador);
            return clientesEliminados;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta cortarCarpeta(Carpeta aCortar, Carpeta padreNuevo, Carpeta padreViejo, int cortador)
            throws RemoteException {
        try {
            Carpeta c= gbd.cortarCarpeta(aCortar, padreNuevo, cortador);
            if (c != null)
                gs.avisoCortarObjeto(aCortar, padreViejo, c, cortador);
            return c;
        } catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta copiarCarpeta(Carpeta aCopiar, Carpeta padreNuevo, int copiador) throws RemoteException {
        try {
            Carpeta c= gbd.copiarCarpeta(aCopiar, padreNuevo, copiador);
            if (c != null)
                gs.avisoActualizarCarpeta(c, copiador, InterfazServiciosServidor.AGREGAR_CARPETA);
            return c;
        } catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }
    
    @Override
    public String crearArchivoTemporal() throws RemoteException {
        String nombre= gs.getIdArchivoTemporal() + EXTENSION_TEMP;
        File archivoTemp= new File(gs.getDirectorioTemporal() + nombre);
        try {
            archivoTemp.createNewFile();
            return nombre;
        } catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }
    
    @Override
    public void escribirArchivoTemporal(String nombreArchivoTemp, byte [] bytes, int len) throws RemoteException {
        File archivoTemp= new File(gs.getDirectorioTemporal() + nombreArchivoTemp);
        try {
            FileOutputStream escritor= new FileOutputStream(archivoTemp, true);
            escritor.write(bytes, 0, len);
            escritor.close();
        } catch (FileNotFoundException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta crearArchivo(Archivo aCrear, Carpeta padre, int quienCrea, String nombreArchivoTemp)
            throws RemoteException {
        try {
            File archivoTemp= new File(gs.getDirectorioTemporal() + nombreArchivoTemp);
            FileInputStream lector= new FileInputStream(archivoTemp);
            Carpeta c= gbd.crearArchivo(aCrear, padre, lector);
            lector.close();
            archivoTemp.delete();
            gs.avisoActualizarCarpeta(c, quienCrea, InterfazServiciosServidor.AGREGAR_ARCHIVO);
            return c;
        } catch (FileNotFoundException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public void abrirArchivo(Archivo aAbrir, int quienAbre) throws RemoteException {
        try {
            Conexion con= gs.getConexion(quienAbre);
            InputStream is= gbd.obtenerBytes(aAbrir, quienAbre);
            byte [] buffer= new byte[TAMANIO_BUFFER];
            int n;
            while ((n= is.read(buffer)) != -1)
                con.getInterfazServiciosCliente().escribirArchivo(aAbrir, buffer, n);
            is.close();
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (RemoteException ex) {this.cerrarArchivo(aAbrir, false, "");
                                      throw new ServiciosServidorException(
                                              ServiciosServidorException.ERROR_ABRIR_ARCHIVO);}
          catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta cambiarNombreArchivo(Archivo aCambiar, Carpeta padre, int quienCambia) throws RemoteException {
        try {
            Carpeta c= gbd.cambiarNombreArchivo(aCambiar, padre, quienCambia);
            if (c != null)
                gs.avisoActualizarCarpeta(c, quienCambia, InterfazServiciosServidor.ORDENAR_ARCHIVOS);
            return c;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public void cerrarArchivo(Archivo aCerrar, boolean guardar, String nombreArchivoTemp) throws RemoteException {
        try {
            if (guardar)
            {
                File archivoTemp= new File(gs.getDirectorioTemporal() + nombreArchivoTemp);
                FileInputStream lector= new FileInputStream(archivoTemp);
                gbd.cerrarArchivo(aCerrar, guardar, lector);
                lector.close();
                archivoTemp.delete();
            }
            else
                gbd.cerrarArchivo(aCerrar, guardar, null); //EL INPUTSTREAM NO SE USA SI NO HAY QUE GUARDAR.
        } catch (FileNotFoundException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (IOException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public boolean eliminarArchivo(Archivo aEliminar, Carpeta padre, int quienElimina) throws RemoteException {
        try {
            boolean b= gbd.eliminarArchivo(aEliminar, quienElimina);
            padre.setPoseeHijos(gbd.poseeHijos(padre));
            if (b)
                gs.avisoQuitarDeCarpeta(padre, aEliminar, quienElimina);
            return b;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta cortarArchivo(Archivo aCortar, Carpeta padreNuevo, Carpeta padreViejo, int quienCorta)
            throws RemoteException {
        try {
            Carpeta c= gbd.cortarArchivo(aCortar, padreNuevo, quienCorta);
            if (c != null)
                gs.avisoCortarObjeto(aCortar, padreViejo, c, quienCorta);
            return c;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public Carpeta copiarArchivo(Archivo aCopiar, Carpeta padreNuevo, int quienCopia) throws RemoteException {
        try {
            Carpeta c= gbd.copiarArchivo(aCopiar, padreNuevo, quienCopia);
            if (c != null)
                gs.avisoActualizarCarpeta(c, quienCopia, InterfazServiciosServidor.AGREGAR_ARCHIVO);
            return c;
        } catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (SQLException ex) {
              if (ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_ELIMINADO ||
                      ex.getErrorCode() == ServiciosServidorException.ERROR_ELEMENTO_OCUPADO)
                  throw new ServiciosServidorException(ex.getErrorCode());
              gs.error(ex.getMessage());
              throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemAgenda> obtenerItemsAgenda(String fecha) throws RemoteException {
        try {
            return gbd.obtenerItemsAgenda(fecha);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemAgenda> crearItemAgenda(ItemAgenda item, int duenio) throws RemoteException {
        try {
            List<ItemAgenda> l= gbd.crearItemAgenda(item);
            gs.avisoActualizarListaAgenda(l, duenio);
            gs.actualizarProximosEventos();
            return l;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public boolean eliminarItemAgenda(ItemAgenda item, int duenio) throws RemoteException {
        try {
            boolean b= gbd.eliminarItemAgenda(item);
            gs.avisoQuitarDeListaAgenda(item, duenio);
            gs.actualizarProximosEventos();
            return b;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemAgenda> modificarItemAgenda(ItemAgenda item, int duenio) throws RemoteException {
        try {
            List<ItemAgenda> l= gbd.modificarItemAgenda(item);
            gs.avisoActualizarListaAgenda(l, duenio);
            gs.actualizarProximosEventos();
            return l;
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<Integer> obtenerDiasConEventosImportantes(String fechaInicio, String fechaFin) throws RemoteException {
        try {
            return gbd.obtenerDiasConEventosImportantes(fechaInicio, fechaFin);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarCarpeta(String palabraClave, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarCarpeta(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarArchivo(String palabraClave, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarArchivo(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarClienteApellido(String palabraClave, boolean concordanciaInicio)
            throws RemoteException {
        try {
            return gbd.buscarClienteApellido(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarClienteNombre(String palabraClave, boolean concordanciaInicio)
            throws RemoteException {
        try {
            return gbd.buscarClienteNombre(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarClienteDni(String palabraClave) throws RemoteException {
        try {
            return gbd.buscarClienteDni(palabraClave);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarExpedienteCaratula(String palabraClave, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarExpedienteCaratula(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarExpedienteInstancia(String palabraClave, int nroInstancia, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarExpedienteInstancia(palabraClave, nroInstancia, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarExpedienteJuzgado(String palabraClave, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarExpedienteJuzgado(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarExpedienteSecretaria(String palabraClave, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarExpedienteSecretaria(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarExpedienteTipo(String palabraClave, boolean concordanciaInicio) throws RemoteException {
        try {
            return gbd.buscarExpedienteTipo(palabraClave, concordanciaInicio);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }

    @Override
    public List<ItemBusqueda> buscarExpedienteEstado(byte estado) throws RemoteException {
        try {
            return gbd.buscarExpedienteEstado(estado);
        } catch (SQLException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
          catch (InterruptedException ex) {gs.error(ex.getMessage()); throw new RemoteException(ERROR_SERVICIO);}
    }
}
